var runtime.gcController

148 uses

	runtime (current package)
		arena.go#L897: 	gcController.heapInUse.add(-int64(s.npages * pageSize))
		arena.go#L903: 	gcController.totalFree.Add(int64(s.elemsize))
		arena.go#L917: 	gcController.update(-int64(s.elemsize), 0)
		arena.go#L1058: 	sysMap(unsafe.Pointer(base), userArenaChunkBytes, &gcController.heapReleased)
		arena.go#L1071: 	gcController.heapInUse.add(int64(userArenaChunkBytes))
		arena.go#L1072: 	gcController.heapReleased.add(-int64(userArenaChunkBytes))
		arena.go#L1084: 	gcController.totalAlloc.Add(int64(s.elemsize))
		arena.go#L1087: 	gcController.update(int64(s.elemsize), 0)
		malloc.go#L618: 	gcController.memoryLimit.Store(maxInt64)
		malloc.go#L648: 		v = h.arena.alloc(n, heapArenaBytes, &gcController.heapReleased)
		mcache.go#L175: 		gcController.totalAlloc.Add(bytesAllocated)
		mcache.go#L212: 	gcController.update(int64(s.npages*pageSize)-int64(usedBytes), int64(c.scanAlloc))
		mcache.go#L246: 	gcController.totalAlloc.Add(int64(npages * pageSize))
		mcache.go#L249: 	gcController.update(int64(s.npages*pageSize), 0)
		mcache.go#L279: 			gcController.totalAlloc.Add(slotsUsed * int64(s.elemsize))
		mcache.go#L306: 	gcController.update(dHeapLive, scanAlloc)
		mem.go#L51: 	gcController.mappedReady.Add(int64(n))
		mem.go#L61: 	gcController.mappedReady.Add(-int64(n))
		mem.go#L76: 	gcController.mappedReady.Add(int64(prepared))
		mem.go#L115: 	gcController.mappedReady.Add(-int64(n))
		mem.go#L129: 	gcController.mappedReady.Add(-int64(n))
		metrics.go#L282: 				out.scalar = uint64(gcController.memoryLimit.Load())
		metrics.go#L288: 				out.scalar = uint64(gcController.gcPercent.Load())
		metrics.go#L295: 				out.scalar = gcController.heapMarked
		metrics.go#L652: 	a.heapGoal = gcController.heapGoal()
		metrics.go#L693: 	a.heapScan = gcController.heapScan.Load()
		metrics.go#L694: 	a.stackScan = gcController.lastStackScan.Load()
		metrics.go#L695: 	a.globalsScan = gcController.globalsScan.Load()
		mgc.go#L187: 	gcController.init(readGOGC(), readGOMEMLIMIT())
		mgc.go#L305: 	delta := now - gcController.markStartTime
		mgc.go#L313: 	return float64(selfTime)/float64(delta) > 1.2*gcController.fractionalUtilizationGoal
		mgc.go#L608: 		trigger, _ := gcController.trigger()
		mgc.go#L609: 		return gcController.heapLive.Load() >= trigger
		mgc.go#L611: 		if gcController.gcPercent.Load() < 0 {
		mgc.go#L707: 	work.heap0 = gcController.heapLive.Load()
		mgc.go#L734: 	gcController.startCycle(now, int(gomaxprocs), trigger)
		mgc.go#L1000: 	gcController.endCycle(now, int(gomaxprocs), work.userForced)
		mgc.go#L1012: 	work.heap1 = gcController.heapLive.Load()
		mgc.go#L1079: 	memstats.lastHeapInUse = gcController.heapInUse.load()
		mgc.go#L1245: 			gcController.assistTime.Load(),
		mgc.go#L1246: 			gcController.dedicatedMarkTime.Load() + gcController.fractionalMarkTime.Load(),
		mgc.go#L1247: 			gcController.idleMarkTime.Load(),
		mgc.go#L1260: 			gcController.lastHeapGoal>>20, " MB goal, ",
		mgc.go#L1261: 			gcController.lastStackScan.Load()>>20, " MB stacks, ",
		mgc.go#L1262: 			gcController.globalsScan.Load()>>20, " MB globals, ",
		mgc.go#L1281: 	if gcController.heapGoal() > minHeapForMetadataHugePages {
		mgc.go#L1516: 		gcController.markWorkerStop(pp.gcMarkWorkerMode, duration)
		mgc.go#L1654: 	gcController.resetLive(work.bytesMarked)
		mgc.go#L1747: 	work.initialHeapLive = gcController.heapLive.Load()
		mgcmark.go#L167: 		workCounter = &gcController.globalsScanWork
		mgcmark.go#L173: 		workCounter = &gcController.globalsScanWork
		mgcmark.go#L195: 		workCounter = &gcController.stackScanWork
		mgcmark.go#L468: 	assistWorkPerByte := gcController.assistWorkPerByte.Load()
		mgcmark.go#L469: 	assistBytesPerWork := gcController.assistBytesPerWork.Load()
		mgcmark.go#L483: 	bgScanCredit := gcController.bgScanCredit.Load()
		mgcmark.go#L493: 		gcController.bgScanCredit.Add(-stolen)
		mgcmark.go#L663: 	assistBytesPerWork := gcController.assistBytesPerWork.Load()
		mgcmark.go#L690: 		gcController.assistTime.Add(pp.gcAssistTime)
		mgcmark.go#L728: 	if gcController.bgScanCredit.Load() > 0 {
		mgcmark.go#L757: 		gcController.bgScanCredit.Add(scanWork)
		mgcmark.go#L761: 	assistBytesPerWork := gcController.assistBytesPerWork.Load()
		mgcmark.go#L795: 		assistWorkPerByte := gcController.assistWorkPerByte.Load()
		mgcmark.go#L797: 		gcController.bgScanCredit.Add(scanWork)
		mgcmark.go#L1236: 			gcController.heapScanWork.Add(gcw.heapScanWork)
		mgcmark.go#L1256: 		gcController.heapScanWork.Add(gcw.heapScanWork)
		mgcmark.go#L1323: 			gcController.heapScanWork.Add(gcw.heapScanWork)
		mgcpacer.go#L88: var gcController gcControllerState
		mgcpacer.go#L460: 			" (scan ", gcController.heapScan.Load()>>20, " MB in ",
		mgcpacer.go#L601: 	gcController.lastHeapGoal = c.heapGoal()
		mgcpacer.go#L864: 		live := gcController.heapLive.Add(dHeapLive)
		mgcpacer.go#L875: 			gcController.heapScan.Add(dHeapScan)
		mgcpacer.go#L1263: 		out = gcController.setGCPercent(in)
		mgcpacer.go#L1310: 		out = gcController.setMemoryLimit(in)
		mgcpacer.go#L1428: 	gcController.commit(isSweepDone())
		mgcpacer.go#L1432: 		gcController.revise()
		mgcpacer.go#L1443: 	trigger, heapGoal := gcController.trigger()
		mgcpacer.go#L1445: 	gcPaceScavenger(gcController.memoryLimit.Load(), heapGoal, gcController.lastHeapGoal)
		mgcscavenge.go#L151: 	return gcController.heapInUse.load() + gcController.heapFree.load()
		mgcscavenge.go#L179: 	mappedReady := gcController.mappedReady.Load()
		mgcscavenge.go#L408: 				gcController.mappedReady.Load() <= scavenge.memoryLimitGoal.Load()
		mgcscavenge.go#L706: 		gcController.heapReleased.load()>>10, " KiB now, ",
		mgcscavenge.go#L707: 		(gcController.heapInUse.load()*100)/heapRetained(), "% util",
		mgcscavenge.go#L783: 				gcController.heapReleased.add(nbytes)
		mgcscavenge.go#L784: 				gcController.heapFree.add(-nbytes)
		mgcsweep.go#L177: 				live := gcController.heapLive.Load()
		mgcsweep.go#L763: 			gcController.totalFree.Add(int64(nfreed) * int64(s.elemsize))
		mgcsweep.go#L799: 			gcController.totalFree.Add(int64(size))
		mgcsweep.go#L925: 	live := gcController.heapLive.Load()
		mgcsweep.go#L991: 		heapLiveBasis := gcController.heapLive.Load()
		mgcwork.go#L144: 		gcController.enlistWorker()
		mgcwork.go#L193: 		gcController.enlistWorker()
		mgcwork.go#L279: 		gcController.heapScanWork.Add(w.heapScanWork)
		mgcwork.go#L304: 		gcController.enlistWorker()
		mheap.go#L1275: 	if limit := gcController.memoryLimit.Load(); !gcCPULimiter.limiting() {
		mheap.go#L1278: 		inuse := gcController.mappedReady.Load()
		mheap.go#L1346: 		gcController.heapReleased.add(-int64(scav))
		mheap.go#L1349: 	gcController.heapFree.add(-int64(nbytes - scav))
		mheap.go#L1351: 		gcController.heapInUse.add(int64(nbytes))
		mheap.go#L1491: 			inUse := gcController.heapFree.load() + gcController.heapReleased.load() + gcController.heapInUse.load()
		mheap.go#L1508: 				sysMap(unsafe.Pointer(h.curArena.base), size, &gcController.heapReleased)
		mheap.go#L1539: 	sysMap(unsafe.Pointer(v), nBase-v, &gcController.heapReleased)
		mheap.go#L1640: 	gcController.heapFree.add(int64(nbytes))
		mheap.go#L1642: 		gcController.heapInUse.add(-int64(nbytes))
		mstats.go#L436: 	totalMapped := gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load() +
		mstats.go#L441: 	heapGoal := gcController.heapGoal()
		mstats.go#L463: 		if gcController.heapInUse.load() != uint64(consStats.inHeap) {
		mstats.go#L464: 			print("runtime: heapInUse=", gcController.heapInUse.load(), "\n")
		mstats.go#L468: 		if gcController.heapReleased.load() != uint64(consStats.released) {
		mstats.go#L469: 			print("runtime: heapReleased=", gcController.heapReleased.load(), "\n")
		mstats.go#L473: 		heapRetained := gcController.heapInUse.load() + gcController.heapFree.load()
		mstats.go#L480: 		if gcController.totalAlloc.Load() != totalAlloc {
		mstats.go#L481: 			print("runtime: totalAlloc=", gcController.totalAlloc.Load(), "\n")
		mstats.go#L485: 		if gcController.totalFree.Load() != totalFree {
		mstats.go#L486: 			print("runtime: totalFree=", gcController.totalFree.Load(), "\n")
		mstats.go#L493: 		if gcController.mappedReady.Load() != totalMapped-uint64(consStats.released) {
		mstats.go#L494: 			print("runtime: mappedReady=", gcController.mappedReady.Load(), "\n")
		mstats.go#L512: 	stats.HeapSys = gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load()
		mstats.go#L529: 	stats.HeapIdle = gcController.heapFree.load() + gcController.heapReleased.load()
		mstats.go#L530: 	stats.HeapInuse = gcController.heapInUse.load()
		mstats.go#L531: 	stats.HeapReleased = gcController.heapReleased.load()
		mstats.go#L951: 		markAssistCpu = gcController.assistTime.Load()
		mstats.go#L952: 		markDedicatedCpu = gcController.dedicatedMarkTime.Load()
		mstats.go#L953: 		markFractionalCpu = gcController.fractionalMarkTime.Load()
		mstats.go#L954: 		markIdleCpu = gcController.idleMarkTime.Load()
		proc.go#L3289: 		gp, tnow := gcController.findRunnableGCWorker(pp, now)
		proc.go#L3387: 	if gcBlackenEnabled != 0 && gcMarkWorkAvailable(pp) && gcController.addIdleMarkWorker() {
		proc.go#L3401: 		gcController.removeIdleMarkWorker()
		proc.go#L3775: 	if atomic.Load(&gcBlackenEnabled) == 0 || !gcController.needIdleMarkWorker() {
		proc.go#L3807: 	if gcBlackenEnabled == 0 || !gcController.addIdleMarkWorker() {
		proc.go#L3817: 		gcController.removeIdleMarkWorker()
		proc.go#L4277: 	gcController.addScannableStack(pp, -int64(gp.stack.hi-gp.stack.lo))
		proc.go#L4299: 		assistWorkPerByte := gcController.assistWorkPerByte.Load()
		proc.go#L4301: 		gcController.bgScanCredit.Add(scanCredit)
		proc.go#L5058: 	gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))
		stack.go#L881: 	gcController.addScannableStack(getg().m.p.ptr(), int64(newsize)-int64(old.hi-old.lo))
		symtab.go#L528: 			gcController.addGlobals(int64(scanDataSize + scanBSSSize))
		traceruntime.go#L603: 	heapGoal := gcController.heapGoal()